Statically-Scoped Exceptions: a Typed Foundation for Aspect-Oriented Error Handling

Aspect-oriented programming systems such as AspectJ provide mechanisms for modularizing crosscutting error-handling concerns. However, AspectJ’s advice does not integrate well with Java’s checked exception mechanism. Furthermore, conventional exception-handling facilities such as AspectJ’s share the problem of accidental exception capture due to the dynamic nature of exception-handling semantics. We propose statically-scoped exceptions as an alternative mechanism for error-handling. In our system, a thrown exception is caught by the nearest lexically-enclosing exception handler, rather than the nearest handler on the call stack. Using static scoping allows us to achieve better modularization, as with AspectJ, and also precudes the problem of exception capture. We provide a static type system that tracks exceptions precisely and ensures that statically-scoped exceptions cannot be misused to cause continuationlike behavior. We hope that our system will serve as a foundation for error handling mechanisms that combine good modularization with strong static reasoning about errors. public class Visitor { public void visitClass(Class o) { try { // method visitor code... } catch (ArchJavaError e) { e.setNode(o); ErrorHandler.print(e); } } public void visitMethod(Method o) { try { // method visitor code... } catch (ArchJavaError e) { e.setNode(o); ErrorHandler.print(e); } } public void visitLiteral(Literal o) { try { // literal visitor code... } catch (ArchJavaError e) { e.setNode(o); ErrorHandler.print(e); } } ... } Figure 1: In this visitor code, taken from the ArchJava compiler, each visit method performs a task such as typechecking on a part of the abstract syntax tree. The visitor code uses exceptions to report typechecking errors; these exceptions must be caught and reported at the end of each visit function before recovering so that typechecking can continue.